package site.wanjiahao.map;

import java.util.Objects;

public class LinkedHashMap<K, V> extends HashMap<K, V> {

    private LinkedNode first;

    private LinkedNode last;

    @Override
    public void clear() {
        super.clear();
        first = null;
        last = null;
    }

    @Override
    public boolean containsValue(V v) {
        LinkedNode node = first;
        while (node != null) {
            if (Objects.equals(node.value, v)) return true;

            node = node.next;
        }
        return false;
    }

    @Override
    protected void afterRemove(Node node, Node willNode) {
        LinkedNode linkedNode = (LinkedNode) node;
        LinkedNode willLinkedNode = (LinkedNode) willNode;
        if (linkedNode != willNode) {
            // 删除为度为2的节点
            LinkedNode tempPrev = willLinkedNode.prev;
            LinkedNode tempNext = willLinkedNode.next;

            willLinkedNode.prev = linkedNode.prev;
            if (linkedNode.prev != null) {
                linkedNode.prev.next = willLinkedNode;
            } else {
                first = willLinkedNode;
            }

            willLinkedNode.next = linkedNode.next;
            if (linkedNode.next != null) {
                linkedNode.next.prev = willLinkedNode;
            } else {
                last = willLinkedNode;
            }


            linkedNode.prev = tempPrev;
            if (tempPrev != null) {
                tempPrev.next = linkedNode;
            } else {
                first = linkedNode;
            }
            linkedNode.next = tempNext;
            if (tempNext != null) {
                tempNext.prev = linkedNode;
            } else {
                last = linkedNode;
            }
        }

        // 删除元素
        LinkedNode next = linkedNode.next;
        LinkedNode prev = linkedNode.prev;

        if (next != null) {
            next.prev = prev;
        } else {
            last = prev;
        }

        if (prev != null) {
            prev.next = next;
        } else {
            first = next;
        }
    }

    // 按照顺序遍历
    @Override
    public void traversal(Consumer<K, V> consumer) {
        if (consumer == null) return;
        LinkedNode node = first;
        while (node != null) {
            if (consumer.accept(node.key, node.value)) return;
            node = node.next;
        }
    }

    @Override
    protected Node createNode(K key, V value, Node parent) {
        LinkedNode linkedNode = new LinkedNode(key, value, parent);
        // 创建节点后维护引用关系
        if (first == null) {
            // 第一次添加节点
            first = linkedNode;
            last = linkedNode;
        } else {
            // 非第一次，也就是当前最后一次
            last.next = linkedNode;
            linkedNode.prev = last;
            last = linkedNode;
        }
        return linkedNode;
    }

    private class LinkedNode extends Node {

        LinkedNode next;

        LinkedNode prev;

        public LinkedNode(K key, V value, Node parent) {
            super(key, value, parent);
        }
    }

}
